package com.cskaoyan.service.impl;

import com.cskaoyan.bean.BasePageInfo;
import com.cskaoyan.bean.MarketBrand;
import com.cskaoyan.bean.MarketBrandExample;
import com.cskaoyan.bean.chenfeng.vo.BrandListVo;
import com.cskaoyan.bean.param.CommonData;
import com.cskaoyan.mapper.MarketBrandMapper;
import com.cskaoyan.service.BrandService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * 品牌制造商service接口实现类
 * 后台系统 → 商场管理 → 品牌制造商
 * 用于处理品牌制造商这部分的业务
 *
 * @author Chen_Feng
 * @since 2022/06/26 11:03
 */
@Service
@Transactional
public class BrandServiceImpl implements BrandService {

    @Value("${file.storage.origin}")
    String webAdress;

    @Autowired
    MarketBrandMapper marketBrandMapper;

    /**
     * 查询
     * 根据搜索栏输入的id和name查询数据库中品牌制造商的信息
     * <p>
     * 其中id是精准查询，如果为null则查询全部，
     * name为模糊查询，如果为null则查询全部。
     * <p>
     * 上面两个条件以 “与” 逻辑进行连接
     *
     * @param basePageInfo 页面限制信息，包含了当前页以及数据数目限制信息
     * @param id           精确查询的id
     * @param name         模糊查询的名字关键字
     * @return com.cskaoyan.bean.param.CommonData<com.cskaoyan.bean.MarketBrand>
     * @author Chen_Feng
     * @since 2022/06/26 12:03
     */
    @Override
    public CommonData<MarketBrand> getBrandByPageAndIdAndName(BasePageInfo basePageInfo, Integer id, String name) {

        // 开启分页
        PageHelper.startPage(basePageInfo.getPage(), basePageInfo.getLimit());

        // 创建example对象，添加准则
        MarketBrandExample marketBrandExample = new MarketBrandExample();
        MarketBrandExample.Criteria criteria = marketBrandExample.createCriteria();
        criteria.andDeletedEqualTo(false);
        if (id != null) {
            criteria.andIdEqualTo(id);
        }
        if (name != null) {
            criteria.andNameLike("%" + name + "%");
        }

        // 调用mapper查询数据库
        List<MarketBrand> list = marketBrandMapper.selectByExample(marketBrandExample);
        handleReturnUrl(list);

        // 获取分页信息
        PageInfo<MarketBrand> pageInfo = new PageInfo<>(list);

        // 封装数据返回结果
        return CommonData.data(pageInfo);
    }

    /**
     * 增加
     * 增加品牌制造商
     *
     * @param marketBrand
     * @return com.cskaoyan.bean.MarketBrand
     * @author Chen_Feng
     * @since 2022/06/26 19:47
     */
    @Override
    public MarketBrand addBrand(MarketBrand marketBrand) {
        // 获得sort_order
        byte sortOrder = getSortOrder(marketBrand);

        // 补充信息
        Date date = new Date();
        marketBrand.setAddTime(date);
        marketBrand.setUpdateTime(date);
        marketBrand.setDeleted(false);
        marketBrand.setSortOrder(sortOrder);

        // 图片路径处理
        String originPicUrl = marketBrand.getPicUrl();
        marketBrand.setPicUrl(originPicUrl.replace(webAdress, ""));

        // 执行数据库的操作
        marketBrandMapper.insert(marketBrand);

        // 图片再处理
        marketBrand.setPicUrl(originPicUrl);

        // 返回结果
        return marketBrand;
    }


    /**
     * 修改
     * 对品牌制造商信息进行修改，同时更新updateTime
     *
     * @param marketBrand
     * @return com.cskaoyan.bean.MarketBrand
     * @author Chen_Feng
     * @since 2022/06/26 19:31
     */
    @Override
    public MarketBrand updateBrand(MarketBrand marketBrand) {

        // 补充信息
        Date date = new Date();
        marketBrand.setUpdateTime(date);
        marketBrand.setDeleted(false);

        // 图片路径处理
        String originPicUrl = marketBrand.getPicUrl();
        marketBrand.setPicUrl(originPicUrl.replace(webAdress, ""));

        // 执行数据库的操作
        marketBrandMapper.updateByPrimaryKeySelective(marketBrand);

        // 图片再处理
        marketBrand.setPicUrl(originPicUrl);

        // 返回结果
        return marketBrand;
    }

    /**
     * 删除（修改）
     * 删除对应id的品牌制造商，准确来说应该是隐藏
     *
     * @param marketBrand
     * @return com.cskaoyan.bean.MarketBrand
     * @author Chen_Feng
     * @since 2022/06/26 19:57
     */
    @Override
    public boolean deleteBrand(MarketBrand marketBrand) {
        // 补充信息
        Date date = new Date();
        marketBrand.setUpdateTime(date);
        marketBrand.setDeleted(true);

        // 执行数据库的操作
        int affectedRows = marketBrandMapper.invisibleBrand(marketBrand);

        // 返回结果
        return affectedRows > 0;
    }

    /**
     * 判断一个品牌商名称是否已经存在于数据库，
     * 判断条件为是否存在一个未处于删除状态的品牌商
     * <p>
     * 存在返回true，不存在返回false
     *
     * @param marketBrand 要判断的品牌商包含的信息
     * @return boolean
     * @author Chen_Feng
     * @since 2022/06/26 22:00
     */
    @Override
    public boolean isBrandExist(MarketBrand marketBrand) {

        // mapper执行查询
        Integer id = marketBrandMapper.selectByBrandName(marketBrand.getName().trim());
        return id != null && !Objects.equals(id, marketBrand.getId());
    }

    /**
     * 获取品牌商列表，以分页形式
     *
     * @param page
     * @param limit
     * @return com.cskaoyan.bean.param.CommonData<com.cskaoyan.bean.chenfeng.vo.BrandListVo>
     * @author Chen_Feng
     * @since 2022/06/29 13:03
     */
    @Override
    public CommonData<BrandListVo> getBrandListByPage(Integer page, Integer limit) {

        // 开启分页
        PageHelper.startPage(page, limit);

        // 执行查询
        List<BrandListVo> list = marketBrandMapper.selectBrandListByPage();

        // 处理图片路径
        for (BrandListVo brandListVo : list) {
            String picUrl = brandListVo.getPicUrl();
            if (picUrl != null && !picUrl.startsWith("http://") && !picUrl.startsWith("https://")) {
                brandListVo.setPicUrl(webAdress + picUrl);
            }
        }

        PageInfo<BrandListVo> pageInfo = new PageInfo<>(list);

        return CommonData.data(pageInfo);
    }

    /**
     * 获取品牌制造商详细信息
     *
     * @param id 要获取的品牌制造商的id
     * @return com.cskaoyan.bean.MarketBrand
     * @author Chen_Feng
     * @since 2022/06/29 13:22
     */
    @Override
    public MarketBrand getBrandDetailByBrandId(Integer id) {

        // 执行查询操作
        MarketBrand marketBrand = marketBrandMapper.selectByPrimaryKey(id);

        // 图片路径处理
        String picUrl = marketBrand.getPicUrl();
        if (!picUrl.startsWith("http://") && !picUrl.startsWith("https://")) {
            marketBrand.setPicUrl(webAdress + picUrl);
        }

        return marketBrand;
    }

    /**
     * 查询最大sort_order的辅助方法
     *
     * @param marketBrand 作比较的对象
     * @return byte
     * @author Chen_Feng
     * @since 2022/06/29 11:39
     */
    private byte getSortOrder(MarketBrand marketBrand) {
        byte result = 1;
        List<MarketBrand> maxSortOrderBrandList = marketBrandMapper.selectBrandWithMaxSortOrder();

        if (maxSortOrderBrandList == null || maxSortOrderBrandList.isEmpty()) {
            return result;
        }

        result = maxSortOrderBrandList.get(0).getSortOrder();
        if (result == Byte.MAX_VALUE) {
            return Byte.MAX_VALUE;
        }

        result = (byte) (result + 1);
        for (MarketBrand brand : maxSortOrderBrandList) {
            if (Objects.equals(brand.getId(), marketBrand.getId())) {
                result = brand.getSortOrder();
                break;
            }
        }
        return result;
    }

    /**
     * 图片路径处理
     *
     * @param list
     * @return void
     * @author Chen_Feng
     * @since 2022/06/29 13:27
     */
    private void handleReturnUrl(List<MarketBrand> list) {
        // 处理图片路径
        for (MarketBrand marketBrand : list) {
            String picUrl = marketBrand.getPicUrl();
            if (picUrl != null && !picUrl.startsWith("http://") && !picUrl.startsWith("https://")) {
                marketBrand.setPicUrl(webAdress + picUrl);
            }
        }
    }
}
